Time Dependent Regular Expression - regexp

A regular expression on the basis of the following operators can be defined in [] . The function TPT.regexp() returns each interval where the expression is true. Otherwise, if no interval is found, the function’s result is undefined.

This element is the basis of regular expressions. In the simplest case a time dependent logical expression is specified in brackets.

Optionally the minimum time of the matching intervals can be specified in curly braces. If the operation e is true in a given interval but is only true for a time shorter than min, it does not match.

Also a minimum and maximum time can be specified in curly braces. Only intervals of a minimum length will match. If the interval is longer than the maximum specified, it will be set at the maximum.

Example

iv = TPT.Boolean()

iv := TPT.regexp([(t >= 1 and t < 2) or (t >= 4 and t < 7)])

# iv is defined in the interval [1,2) and [4,7)

iv = TPT.Boolean()
iv := TPT.regexp([(t >= 1 and t < 2) or (t >= 4 and t < 7)]{2})
# iv is defined only in the interval [4,7) because [1,2) is shorter than 2

iv = TPT.Boolean()
iv := TPT.regexp([(t >= 1 and t < 2) or (t >= 4 and t < 9)]{2,2})
# iv is defined in the interval [4,6) and [6,8)
# it is cut in 2 intervals with length 2
Any structure like [c(t)==X] used within interval calculation corresponds to one interval, formed by an arbitrary number of many consecutive samples where the condition is fulfilled.
The different intervals in the following examples will be referred as i1, i2, i3, i4, etc.
For example: ([c(t) == 1]([c(t) == 2][c(t) == 3])*[c(t) == 4] where:
[c(t) == 1] is i1
[c(t) == 2] is i2
[c(t) == 3] is i3
[c(t) == 4] is i4

The suffix * helps to define expressions that match arbitrarily often.

This means to match zero or more times (0- to n-times).

Example
iv = TPT.Boolean()

iv := TPT.regexp([c(t) == 1]([c(t) == 2][c(t) == 3])*[c(t) == 4]);

# where ([c(t) == 2][c(t) == 3]) must be fulfilled zero or more times

# Valid intervals would be

#i1,i4

#i1,i2,i3,i4

#i1,i2,i3,i2,i3,i4 and so on

The suffix + helps to define expressions that match at least once but also very often (1 to n times).

This means to match one or more times.

Example
iv = TPT.Boolean()

iv := TPT.regexp([c(t) == 1]([c(t) == 2][c(t) == 3])+[c(t) == 4]);

# where ([c(t) == 2][c(t) == 3]) must be fulfilled at least once or more times

# Valid intervals would be

#i1,i2,i3,i4

#i1,i2,i3,i2,i3,i4 and so on

The suffix ? helps to define expressions that match conditionally: it matches once or not at all. The expression can match also a void interval.

Example
iv = TPT.Boolean()

iv := TPT.regexp([c(t) == 1]([c(t) == 2][c(t) == 3])?[c(t) == 4]);

# where ([c(t) == 2][c(t) == 3]) must be fulfilled at once or not at all

# Valid intervals are only i1,i4 and i1,i2,i3,i4


Expressions can be parenthesized generating blocks using braces ('and').

As many regular expressions as desired can be written one after another without an explicit operator. The expressions will be evaluated in order from left to right.

Example

# search each interval where c is first 3 and then 4
iv = TPT.Boolean()
iv := TPT.regexp([c(t) == 3] [c(t) == 4])

This operator is used to match either the left or the right expression.

Example

The example matches to intervals where c is first 3 and then 4 or constant 5.

iv = TPT.Boolean()

iv := TPT.regexp(([c(t) == 3][c(t) == 4])|[c(t) == 5]);

# 333444 or 555555

Expressions in parentheses can be explicitly named in order to access the matched expression later on.

Example

In this example cEquals4 is defined as a void variable. After the calculation the part intervals that match c(t)==4 are taken.

# search each interval where c is first 3 and then 4
cEquals4 = TPT.Boolean()
iv = TPT.Boolean()
iv := TPT.regexp(([c(t) == 3] cEquals4 := [c(t) == 4])+)
# 333444333444333444…
# cEquals4 is defined during parts where c(t) is 4

The prefix ^ of a regular expression says that this expression must start at the very beginning of the actual time interval.

Example

iv1 = TPT.Boolean()
iv1 := TPT.regexp(^[t <= 1]); # matches to the interval [0, 1)
iv2 = TPT.Boolean()
iv2 := TPT.regexp(^[t >= 1]); # doesn't match since t >= 1 is not true at t=0

The suffix "$" says that the expression must match until the very end of a time interval.

Example

This expression matches only to intervals where in the actual context c(t)==3 is true until the end of the interval.

iv = TPT.Boolean();
iv := TPT.regexp([c(t) == 3]$);
Example 1

We want to check whether headlight stays OFF when light_switch is set from OFF to AUTO in bright_ambient conditions. In the first regular expression, the context interval where light_switch is set to AUTO is defined. During this context interval, a nested interval is defined with the second regular expression. It determines an interval where light intensity was above MIN_LIGHT_OFF at the beginning of the context interval and afterward does not fall below MIN_LIGHT_ON. Here the meaning of the ? operator is that if light_intensity falls below MIN_LIGHT_OFF it does stay above MIN_LIGHT_ON or the context interval is terminated. Because of the ?, also intervals where light_intensity does not fall below MIN_LIGHT_OFF are considered.

during TPT.regexp([light_switch(t) == 2]):
# check change to AUTO MODE
during TPT.regexp(^[light_intensity(t)>MIN_LIGHT_OFF]
[light_intensity(t)>MIN_LIGHT_ON]?):
# ambient conditions were bright when light switch was set to AUTO
Check_AUTO_bright = TPT.BooleanX("Check switch to AUTO bright")
Check_AUTO_bright := TPT.checkAlways(headlight(t) == 0,
"switch to AUTO with bright ambient, headlight OFF",
"switch to AUTO with bright ambient, but headlight not OFF")

Regular expression example 1
Example B

We define an interval that starts when a condition is fulfilled for the first time and ends at the end of the test sequence. The example below shows how to find the interval starting where a(t) falls below -0.1 for the first time . The interval lasts until the end of the test sequence.

a = TPT.DoubleX()
a(t) := sin(t)
iv = TPT.BooleanX()
iv := TPT.regexp([a(t) < -0.1][t>0]?)
# iv is defined in the interval where a(t) is below -0.1 for the first time
# until the end of the test interval
# in this case the interval is [3.25s; 60s]

Regular expression example 2